{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                               Sentence  SUBJpolit\n",
      "0     and jane confident story its going come back a...          1\n",
      "1     click expand nick esposito yearold skydiving i...          1\n",
      "2     its still early story even remdesivir approved...          1\n",
      "3     this image released apple tv plus show tom han...          1\n",
      "4     kurtulmu also said constantly calling internat...          1\n",
      "...                                                 ...        ...\n",
      "6365  speaking cnn last week herald square midtown m...          2\n",
      "6366  these gigantic structure made countless clump ...          1\n",
      "6367  the solar orbiter spacecraft beamed back close...          2\n",
      "6368  the vote today nothing liz cheneys vote impeac...          2\n",
      "6369  but theres even depth tree empty socket slotte...          1\n",
      "\n",
      "[6370 rows x 2 columns]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1    3674\n",
       "2    2696\n",
       "Name: SUBJpolit, dtype: int64"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import re\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import SnowballStemmer\n",
    "import pymongo\n",
    "import os\n",
    "stop = stopwords.words('english')\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\"\n",
    "from tqdm import tqdm\n",
    "import joblib\n",
    "from nltk.stem.wordnet import WordNetLemmatizer\n",
    "import string\n",
    "df = pd.read_csv('../data/version2.csv',encoding = 'ISO-8859-1')\n",
    "# cols = [col for col in df if not col.startswith('Unnamed:')]\n",
    "# df = df[cols]\n",
    "print(df)\n",
    "b_set = df\n",
    "b_set['SUBJpolit'].value_counts()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#part 2 - bert fine-tuned\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch import optim\n",
    "import transformers as tfs\n",
    "import math\n",
    "\n",
    "class BertClassificationModel(nn.Module):\n",
    "    def __init__(self,dropout=0.2):\n",
    "        super(BertClassificationModel, self).__init__()   \n",
    "        model_class, tokenizer_class, pretrained_weights = (tfs.BertModel, tfs.BertTokenizer, 'bert-base-uncased')         \n",
    "        self.tokenizer = tokenizer_class.from_pretrained(pretrained_weights)\n",
    "        self.bert = model_class.from_pretrained(pretrained_weights)\n",
    "        self.dense = nn.Linear(768, 2)  #The default number of hidden units in bert is 768, and the output unit is 2, which means two classifications\n",
    "\n",
    "        \n",
    "    def forward(self, batch_sentences):\n",
    "        batch_tokenized = self.tokenizer.batch_encode_plus(batch_sentences, add_special_tokens=True,\n",
    "                                max_length=77,truncation=True, pad_to_max_length=True)      #tokenize、add special token、pad\n",
    "        input_ids = torch.tensor(batch_tokenized['input_ids'])\n",
    "        attention_mask = torch.tensor(batch_tokenized['attention_mask'])\n",
    "        bert_output = self.bert(input_ids, attention_mask=attention_mask)\n",
    "        dp = nn.Dropout(0.2)\n",
    "        bert_cls_hidden_state = dp(bert_output[0][:,0,:])       #Extract the hidden state corresponding to [CLS]\n",
    "        linear_output = self.dense(bert_cls_hidden_state)\n",
    "        return linear_output\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# b_set = joblib.load('../models/4000.data')\n",
    "sentences = b_set['Sentence'].values\n",
    "targets = b_set['SUBJpolit'].values\n",
    "targets = targets - 1\n",
    "rann = 2\n",
    "train_inputs, test_inputs, train_targets, test_targets = train_test_split(sentences, targets, random_state=rann)\n",
    "save_dict = {\n",
    "    'train_inputs':train_inputs, \n",
    "    'test_inputs':test_inputs,\n",
    "    'train_targets':train_targets,\n",
    "    'test_targets':test_targets  \n",
    "}\n",
    "# joblib.dump(save_dict,'../data/4000_train_test_data_'+str(rann)+'.data')\n",
    "# train_inputs, test_inputs, train_targets, test_targets = joblib.load('../data/4000_train_test_data_1.data').values()\n",
    "batch_size = 64\n",
    "batch_count = int(len(train_inputs) / batch_size)\n",
    "test_batch_count = int(len(test_inputs) / batch_size)\n",
    "batch_train_inputs, batch_train_targets = [], []\n",
    "batch_test_inputs, batch_test_targets = [], []\n",
    "for i in range(batch_count):\n",
    "    batch_train_inputs.append(train_inputs[i*batch_size : (i+1)*batch_size])\n",
    "    batch_train_targets.append(train_targets[i*batch_size : (i+1)*batch_size])\n",
    "    batch_test_inputs.append(test_inputs[i*batch_size : (i+1)*batch_size])\n",
    "    batch_test_targets.append(test_targets[i*batch_size : (i+1)*batch_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4777\n",
      "1593\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 0, ..., 0, 0, 0], dtype=int64)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(len(train_inputs))\n",
    "print(len(test_inputs)) \n",
    "test_targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 0, 0, 1], dtype=int64)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.weight']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [03:10<00:00,  8.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 42.44%\n",
      "Batch: 5, train_Loss: 0.7419\n",
      "Batch: 10, train_Loss: 0.6547\n",
      "Batch: 15, train_Loss: 0.5538\n",
      "Batch: 20, train_Loss: 0.5464\n",
      "Batch: 25, train_Loss: 0.5898\n",
      "Batch: 30, train_Loss: 0.5013\n",
      "Batch: 35, train_Loss: 0.5638\n",
      "Batch: 40, train_Loss: 0.5265\n",
      "Batch: 45, train_Loss: 0.4794\n",
      "Batch: 50, train_Loss: 0.4871\n",
      "Batch: 55, train_Loss: 0.4455\n",
      "Batch: 60, train_Loss: 0.4872\n",
      "Batch: 65, train_Loss: 0.4263\n",
      "Batch: 70, train_Loss: 0.3976\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:44<00:00,  9.69it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 83.24%\n",
      "Batch: 5, train_Loss: 0.4547\n",
      "Batch: 10, train_Loss: 0.4792\n",
      "Batch: 15, train_Loss: 0.4128\n",
      "Batch: 20, train_Loss: 0.4097\n",
      "Batch: 25, train_Loss: 0.4321\n",
      "Batch: 30, train_Loss: 0.3814\n",
      "Batch: 35, train_Loss: 0.4060\n",
      "Batch: 40, train_Loss: 0.4792\n",
      "Batch: 45, train_Loss: 0.4153\n",
      "Batch: 50, train_Loss: 0.3258\n",
      "Batch: 55, train_Loss: 0.3419\n",
      "Batch: 60, train_Loss: 0.4164\n",
      "Batch: 65, train_Loss: 0.3534\n",
      "Batch: 70, train_Loss: 0.2971\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:31<00:00, 10.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 77.28%\n",
      "Batch: 5, train_Loss: 0.3955\n",
      "Batch: 10, train_Loss: 0.3232\n",
      "Batch: 15, train_Loss: 0.3469\n",
      "Batch: 20, train_Loss: 0.3029\n",
      "Batch: 25, train_Loss: 0.3063\n",
      "Batch: 30, train_Loss: 0.3603\n",
      "Batch: 35, train_Loss: 0.3591\n",
      "Batch: 40, train_Loss: 0.3654\n",
      "Batch: 45, train_Loss: 0.3565\n",
      "Batch: 50, train_Loss: 0.2373\n",
      "Batch: 55, train_Loss: 0.2422\n",
      "Batch: 60, train_Loss: 0.2441\n",
      "Batch: 65, train_Loss: 0.2059\n",
      "Batch: 70, train_Loss: 0.2043\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [04:08<00:00,  6.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 80.23%\n",
      "Batch: 5, train_Loss: 0.3334\n",
      "Batch: 10, train_Loss: 0.2848\n",
      "Batch: 15, train_Loss: 0.2588\n",
      "Batch: 20, train_Loss: 0.2476\n",
      "Batch: 25, train_Loss: 0.2552\n",
      "Batch: 30, train_Loss: 0.3288\n",
      "Batch: 35, train_Loss: 0.2934\n",
      "Batch: 40, train_Loss: 0.3262\n",
      "Batch: 45, train_Loss: 0.2261\n",
      "Batch: 50, train_Loss: 0.1939\n",
      "Batch: 55, train_Loss: 0.2090\n",
      "Batch: 60, train_Loss: 0.1751\n",
      "Batch: 65, train_Loss: 0.2708\n",
      "Batch: 70, train_Loss: 0.1959\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [04:03<00:00,  6.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 79.85%\n",
      "Batch: 5, train_Loss: 0.2277\n",
      "Batch: 10, train_Loss: 0.2171\n",
      "Batch: 15, train_Loss: 0.2144\n",
      "Batch: 20, train_Loss: 0.2134\n",
      "Batch: 25, train_Loss: 0.1915\n",
      "Batch: 30, train_Loss: 0.3373\n",
      "Batch: 35, train_Loss: 0.2949\n",
      "Batch: 40, train_Loss: 0.2996\n",
      "Batch: 45, train_Loss: 0.2246\n",
      "Batch: 50, train_Loss: 0.1526\n",
      "Batch: 55, train_Loss: 0.1292\n",
      "Batch: 60, train_Loss: 0.1513\n",
      "Batch: 65, train_Loss: 0.1876\n",
      "Batch: 70, train_Loss: 0.2166\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [04:11<00:00,  6.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 82.49%\n",
      "Batch: 5, train_Loss: 0.2378\n",
      "Batch: 10, train_Loss: 0.2245\n",
      "Batch: 15, train_Loss: 0.1774\n",
      "Batch: 20, train_Loss: 0.1742\n",
      "Batch: 25, train_Loss: 0.1405\n",
      "Batch: 30, train_Loss: 0.3289\n",
      "Batch: 35, train_Loss: 0.2641\n",
      "Batch: 40, train_Loss: 0.3109\n",
      "Batch: 45, train_Loss: 0.1892\n",
      "Batch: 50, train_Loss: 0.1754\n",
      "Batch: 55, train_Loss: 0.1954\n",
      "Batch: 60, train_Loss: 0.1917\n",
      "Batch: 65, train_Loss: 0.1232\n",
      "Batch: 70, train_Loss: 0.1165\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:34<00:00, 10.32it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 83.68%\n",
      "Batch: 5, train_Loss: 0.1879\n",
      "Batch: 10, train_Loss: 0.1980\n",
      "Batch: 15, train_Loss: 0.1956\n",
      "Batch: 20, train_Loss: 0.1847\n",
      "Batch: 25, train_Loss: 0.1164\n",
      "Batch: 30, train_Loss: 0.1876\n",
      "Batch: 35, train_Loss: 0.2284\n",
      "Batch: 40, train_Loss: 0.2356\n",
      "Batch: 45, train_Loss: 0.1594\n",
      "Batch: 50, train_Loss: 0.1092\n",
      "Batch: 55, train_Loss: 0.1058\n",
      "Batch: 60, train_Loss: 0.1598\n",
      "Batch: 65, train_Loss: 0.1217\n",
      "Batch: 70, train_Loss: 0.0733\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:31<00:00, 10.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 79.79%\n",
      "Batch: 5, train_Loss: 0.2887\n",
      "Batch: 10, train_Loss: 0.2077\n",
      "Batch: 15, train_Loss: 0.1871\n",
      "Batch: 20, train_Loss: 0.1597\n",
      "Batch: 25, train_Loss: 0.1496\n",
      "Batch: 30, train_Loss: 0.1356\n",
      "Batch: 35, train_Loss: 0.1488\n",
      "Batch: 40, train_Loss: 0.1641\n",
      "Batch: 45, train_Loss: 0.1652\n",
      "Batch: 50, train_Loss: 0.0904\n",
      "Batch: 55, train_Loss: 0.0848\n",
      "Batch: 60, train_Loss: 0.1597\n",
      "Batch: 65, train_Loss: 0.1566\n",
      "Batch: 70, train_Loss: 0.0746\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:33<00:00, 10.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 79.35%\n",
      "Batch: 5, train_Loss: 0.1224\n",
      "Batch: 10, train_Loss: 0.1690\n",
      "Batch: 15, train_Loss: 0.0779\n",
      "Batch: 20, train_Loss: 0.1240\n",
      "Batch: 25, train_Loss: 0.0440\n",
      "Batch: 30, train_Loss: 0.0899\n",
      "Batch: 35, train_Loss: 0.1273\n",
      "Batch: 40, train_Loss: 0.1534\n",
      "Batch: 45, train_Loss: 0.0832\n",
      "Batch: 50, train_Loss: 0.0697\n",
      "Batch: 55, train_Loss: 0.1071\n",
      "Batch: 60, train_Loss: 0.1340\n",
      "Batch: 65, train_Loss: 0.1422\n",
      "Batch: 70, train_Loss: 0.1129\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:31<00:00, 10.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 82.42%\n",
      "Batch: 5, train_Loss: 0.1456\n",
      "Batch: 10, train_Loss: 0.1032\n",
      "Batch: 15, train_Loss: 0.1422\n",
      "Batch: 20, train_Loss: 0.0662\n",
      "Batch: 25, train_Loss: 0.0609\n",
      "Batch: 30, train_Loss: 0.0491\n",
      "Batch: 35, train_Loss: 0.0774\n",
      "Batch: 40, train_Loss: 0.0582\n",
      "Batch: 45, train_Loss: 0.0608\n",
      "Batch: 50, train_Loss: 0.0730\n",
      "Batch: 55, train_Loss: 0.0426\n",
      "Batch: 60, train_Loss: 0.0378\n",
      "Batch: 65, train_Loss: 0.0348\n",
      "Batch: 70, train_Loss: 0.0414\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:29<00:00, 10.62it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 83.99%\n",
      "Batch: 5, train_Loss: 0.0338\n",
      "Batch: 10, train_Loss: 0.0572\n",
      "Batch: 15, train_Loss: 0.0771\n",
      "Batch: 20, train_Loss: 0.0554\n",
      "Batch: 25, train_Loss: 0.0490\n",
      "Batch: 30, train_Loss: 0.0327\n",
      "Batch: 35, train_Loss: 0.0593\n",
      "Batch: 40, train_Loss: 0.0958\n",
      "Batch: 45, train_Loss: 0.0289\n",
      "Batch: 50, train_Loss: 0.0447\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-691f81faee8c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     40\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     41\u001b[0m \u001b[1;31m#         test_loss = criterion(test_outputs, test_labels)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 42\u001b[1;33m         \u001b[0mloss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     43\u001b[0m \u001b[1;31m#         loss.backward(retain_graph=True)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     44\u001b[0m \u001b[1;31m#         test_loss.backward()\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\anaconda\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m    243\u001b[0m                 \u001b[0mcreate_graph\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    244\u001b[0m                 inputs=inputs)\n\u001b[1;32m--> 245\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    246\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    247\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\anaconda\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m    143\u001b[0m         \u001b[0mretain_graph\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    144\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 145\u001b[1;33m     Variable._execution_engine.run_backward(\n\u001b[0m\u001b[0;32m    146\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    147\u001b[0m         allow_unreachable=True, accumulate_grad=True)  # allow_unreachable flag\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import joblib\n",
    "import torch.nn.functional as F\n",
    "\n",
    "#train the model\n",
    "epochs = 14\n",
    "lr = 0.01\n",
    "print_every_batch = 5\n",
    "bert_classifier_model = BertClassificationModel()\n",
    "\n",
    "# bert_classifier_model = joblib.load('../models/epoch_v1_3_4000_pure_bert.b')\n",
    "# torch.autograd.set_detect_anomaly(True)\n",
    "optimizer = optim.SGD(bert_classifier_model.parameters(), lr=lr, momentum=0.9)\n",
    "# test_optimizer = optim.SGD(bert_classifier_model.parameters(), lr=lr, momentum=0.9)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "accuracy_sets = []\n",
    "train_loss_set, test_loss_set = [],[]\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    print_train_avg_loss = 0\n",
    "    print_test_avg_loss = 0\n",
    "    total = len(test_inputs)\n",
    "    hit = 0\n",
    "    with torch.no_grad():\n",
    "        for i in tqdm(range(total)):\n",
    "            outputs = bert_classifier_model([test_inputs[i]])\n",
    "            _, predicted = torch.max(outputs, 1)\n",
    "            if predicted == test_targets[i]:\n",
    "                hit += 1\n",
    "    print(\"Accuracy: %.2f%%\" % (hit / total * 100))\n",
    "    for i in range(batch_count):\n",
    "        inputs = batch_train_inputs[i]\n",
    "        labels = torch.tensor(batch_train_targets[i])  \n",
    "        optimizer.zero_grad()\n",
    "        outputs = bert_classifier_model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        print_train_avg_loss += loss.item()\n",
    "        if i % print_every_batch == (print_every_batch-1):\n",
    "            print(\"Batch: %d, train_Loss: %.4f\" % ((i+1), print_train_avg_loss/print_every_batch))\n",
    "            train_loss_set.append(print_train_avg_loss/print_every_batch)\n",
    "            print_train_avg_loss = 0\n",
    "    \n",
    "    accuracy_sets.append((hit / total * 100))\n",
    "    joblib.dump(bert_classifier_model,'../models/epoch_v4_'+str(epoch)+'_6370_pure_bert.b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_loss_set = [0.2400,0.0466,0.0177,0.0111,0.0073,0.0055]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6863576584392123, 0.641100788116455, 0.5966056558820937, 0.5396867076555888, 0.46535646518071494, 0.3451263752248552, 0.20024674899048275, 0.09710024918119113, 0.04962899291680919, 0.051748920087185166, 0.09352024245179363, 0.13894150161908733, 0.03981766442043913, 0.020581354687197337]\n",
      "[51.74035747883349, 61.429915333960494, 63.78174976481655, 65.09877704609596, 65.56914393226717, 65.6632173095014, 66.22765757290688, 66.69802445907807, 66.5098777046096, 63.593603010348076, 66.32173095014112, 66.60395108184383, 65.6632173095014, 65.56914393226717]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "los_set = [sum(j)/float(len(j))  for j in (train_loss_set[i: i+9] \n",
    " for i in range(0,len(train_loss_set),9))\n",
    "]\n",
    "print(los_set)\n",
    "print(accuracy_sets)\n",
    "joblib.dump(los_set,'../data/e14_train_loss_set.list')\n",
    "joblib.dump(accuracy_sets,'../data/e14_accuracy_sets.list')\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(range(len(accuracy_sets)),los_set, label=\"loss\")\n",
    "plt.ylabel(\"bert-10k-dataset\")\n",
    "plt.xlabel(\"epochs\")\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(range(len(accuracy_sets)),accuracy_sets, label=\"accuracy\")\n",
    "plt.ylabel(\"bert-10k-dataset\")\n",
    "plt.xlabel(\"epochs\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                                                         | 0/1593 [00:00<?, ?it/s]D:\\anaconda\\lib\\site-packages\\transformers\\tokenization_utils_base.py:2104: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
      "  warnings.warn(\n",
      "<ipython-input-86-3a5143911442>:27: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  probs = sm(outputs)\n",
      "100%|██████████████████████████████████████████████████████████████████████████████| 1593/1593 [02:56<00:00,  9.01it/s]\n",
      "D:\\anaconda\\lib\\site-packages\\transformers\\tokenization_utils_base.py:2104: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8629300732216126\n",
      "0.8630017542892878\n",
      "0.8631722260040844\n",
      "124\n"
     ]
    }
   ],
   "source": [
    "# eval the trained model\n",
    "# epoch_v4_7_4000_pure_bert.b\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import roc_curve                \n",
    "from sklearn.metrics import recall_score   \n",
    "from sklearn.metrics import f1_score         \n",
    "import matplotlib.pyplot as plt\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
    "\n",
    "bert_classifier_model = joblib.load('../models/epoch_v4_9_6370_pure_bert.b')\n",
    "sentences = b_set['Sentence'].values\n",
    "targets = b_set['SUBJpolit'].values\n",
    "targets = targets - 1\n",
    "rann = 2\n",
    "train_inputs, test_inputs, train_targets, test_targets = train_test_split(sentences, targets, random_state=rann)\n",
    "total = len(test_inputs)\n",
    "hit = 0\n",
    "pres=[]\n",
    "recalls=[]\n",
    "f1scores=[]\n",
    "bert_drop_item = []\n",
    "y_pred_probs = []\n",
    "with torch.no_grad():\n",
    "    for i in tqdm(range(total)):\n",
    "        sm = torch.nn.Softmax()\n",
    "        outputs = bert_classifier_model([test_inputs[i]])\n",
    "        probs = sm(outputs)\n",
    "        y_pred_probs.append(probs[0].detach().numpy())\n",
    "    \n",
    "df_new = pd.DataFrame()\n",
    "df_new['features'] = test_inputs.tolist()\n",
    "df_new['label'] = test_targets\n",
    "# lr_clf = joblib.load('../models/6370lr_clf.clf')\n",
    "# model = svm_clf\n",
    "# y_pred = y_pred_prob[:, 1]\n",
    "# print(y_pred)\n",
    "probs = pd.DataFrame(np.array(y_pred_probs).max(axis=1),columns=['prob'])\n",
    "hs = pd.concat((df_new,probs),axis=1)\n",
    "hs1 = hs[hs['prob']>=0.8]\n",
    "\n",
    "hs1_res = [torch.max(bert_classifier_model([s]),1)[1].item()+1 for s in hs1['features'].values]\n",
    "print(precision_score(hs1_res,hs1['label'].values.astype('int')+1,average='weighted'))\n",
    "print(f1_score(hs1_res,hs1['label'].values.astype('int')+1,average='weighted'))\n",
    "print(recall_score(hs1_res,hs1['label'].values.astype('int')+1,average='weighted'))\n",
    "print(len(df_new['label']) - len(hs1))\n",
    "\n",
    "# bert_drop_item.append(y_pred_probs.count(0))\n",
    "# pres.append(precision_score(test_targets,y_pred_probs,average='weighted'))\n",
    "# recalls.append(recall_score(test_targets,y_pred_probs,average='weighted'))\n",
    "# f1scores.append(f1_score(test_targets,y_pred_probs,average='weighted'))\n",
    "# plt.plot(thresset, pres, label=\"BERT precision\")\n",
    "# plt.plot(thresset, recalls, label=\"BERT recall\")\n",
    "# plt.plot(thresset, f1scores, label=\"BERT f1-score\")\n",
    "# plt.ylabel(\"value\")\n",
    "# plt.xlabel(\"threshold\")\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "# print(\"Accuracy: %.2f%%\" % precision_score(test_targets,y_pred_probs,average='weighted'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import joblib\n",
    "\n",
    "joblib.dump(train_last_hidden_states,'../models/8583_clear.bert')\n",
    "print(b_set['SUBJpolit'])\n",
    "b_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 0, ..., 0, 0, 0], dtype=int64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "training_accuracy = []\n",
    "test_accuracy = []\n",
    "train_features = train_last_hidden_states[0][:,0,:].numpy()\n",
    "train_labels = b_set['SUBJpolit']\n",
    "r_set = range(1,12)\n",
    "test_accuracy = []\n",
    "for i in r_set:\n",
    "    train_features, test_features, train_labels, test_labels = train_test_split(train_features, train_labels.astype('int'), random_state=i)\n",
    "    lr_clf = LogisticRegression()\n",
    "    lr_clf.fit(train_features, train_labels)\n",
    "    test_accuracy.append(lr_clf.score(test_features, test_labels))\n",
    "plt.plot(r_set, test_accuracy, label=\"lr test accuracy\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.xlabel(\"random_state\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "# svm\n",
    "train_features, test_features, train_labels, test_labels = train_test_split(train_features, train_labels.astype('int'), random_state=11)\n",
    "\n",
    "clf = SVC(C=0.8, kernel='linear', gamma=20, decision_function_shape='ovr')\n",
    "clf.fit(X_train, Y_train.astype('int').ravel())\n",
    "print (clf.score(X_test, Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.naive_bayes import ComplementNB\n",
    "from sklearn.naive_bayes import BernoulliNB \n",
    "from sklearn.naive_bayes import CategoricalNB\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import precision_score\n",
    "\n",
    "\n",
    "training_accuracy = []\n",
    "gnb_test_accuracy = []\n",
    "bnb_test_accuracy = []\n",
    "svm_test_accuracy = []\n",
    "lr_test_accuracy=[]\n",
    "gnb = GaussianNB()\n",
    "bnb = BernoulliNB()\n",
    "lr_clf = LogisticRegression()\n",
    "svm_clf = SVC(C=0.8, kernel='linear', gamma=20, decision_function_shape='ovr')\n",
    "sets = [0+(i/100)*2 for i in range(1,10)]\n",
    "r_set = range(1,12)\n",
    "\n",
    "for i in r_set:\n",
    "    X_train, X_test, Y_train, Y_test = train_test_split(train_features, train_labels.astype('int'), random_state=i)\n",
    "    y_pred = gnb.fit(X_train, Y_train).predict(X_test)\n",
    "    y_pred4 = bnb.fit(X_train, Y_train).predict(X_test)\n",
    "    svm_clf.fit(X_train, Y_train.ravel())\n",
    "    lr_clf.fit(X_train, Y_train)\n",
    "    test_accuracy.append(lr_clf.score(test_features, test_labels))\n",
    "    svm_test_accuracy.append(clf.score(X_test, Y_test))\n",
    "    lr_test_accuracy.append(lr_clf.score(X_test, Y_test))\n",
    "    gnb_test_accuracy.append((Y_test == y_pred).sum()/X_test.shape[0])\n",
    "    bnb_test_accuracy.append((Y_test == y_pred4).sum()/X_test.shape[0])\n",
    "plt.plot(r_set, lr_test_accuracy, label=\"LR accuracy\")\n",
    "plt.plot(r_set, svm_test_accuracy, label=\"SVM accuracy\")\n",
    "plt.plot(r_set, gnb_test_accuracy, label=\"GaussianNB accuracy\")\n",
    "plt.plot(r_set, bnb_test_accuracy, label=\"BernoulliNB accuracy\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.xlabel(\"random_state\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best lr: 0.573529, avg: 0.500000\n",
      "best svm: 0.647059, avg: 0.565508\n",
      "best gnb: 0.573529, avg: 0.516043\n",
      "best bb: 0.588235, avg: 0.544118\n"
     ]
    }
   ],
   "source": [
    "print(\"best lr: %f, avg: %f\" % (max(lr_test_accuracy),(sum(lr_test_accuracy)/len(lr_test_accuracy))))\n",
    "print(\"best svm: %f, avg: %f\" % (max(svm_test_accuracy),(sum(svm_test_accuracy)/len(svm_test_accuracy))))\n",
    "print(\"best gnb: %f, avg: %f\" % (max(gnb_test_accuracy),(sum(gnb_test_accuracy)/len(gnb_test_accuracy))))\n",
    "print(\"best bb: %f, avg: %f\" % (max(bnb_test_accuracy),(sum(bnb_test_accuracy)/len(bnb_test_accuracy))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.6666666666666666,\n",
       " 0.3333333333333333,\n",
       " 0.3333333333333333,\n",
       " 0.5,\n",
       " 0.6666666666666666,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 0.5,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 0.8333333333333334]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.3333333333333333,\n",
       " 1.0,\n",
       " 0.6666666666666666,\n",
       " 1.0,\n",
       " 0.5,\n",
       " 1.0,\n",
       " 0.8333333333333334,\n",
       " 0.5,\n",
       " 0.6666666666666666,\n",
       " 1.0,\n",
       " 0.5]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.3333333333333333,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 0.8333333333333334,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 0.8333333333333334,\n",
       " 0.8333333333333334,\n",
       " 0.5]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gnb_test_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.3333333333333333,\n",
       " 0.8333333333333334,\n",
       " 0.6666666666666666,\n",
       " 1.0,\n",
       " 0.5,\n",
       " 0.6666666666666666,\n",
       " 0.6666666666666666,\n",
       " 0.3333333333333333,\n",
       " 0.5,\n",
       " 0.6666666666666666,\n",
       " 0.6666666666666666]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bnb_test_accuracy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
